/*
 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.nulldev.util.graphics.renderIt.ginterfaces.marlin.impl.pisces;

import static com.nulldev.util.graphics.renderIt.ginterfaces.marlin.impl.pisces.MarlinUtils.logInfo;

import java.util.Arrays;

public final class ArrayCacheConst implements MarlinConst {

	static final int BUCKETS = 8;
	static final int MIN_ARRAY_SIZE = 4096;
	// maximum array size
	static final int MAX_ARRAY_SIZE;
	// threshold below to grow arrays by 4
	static final int THRESHOLD_SMALL_ARRAY_SIZE = 4 * 1024 * 1024;
	// threshold to grow arrays only by (3/2) instead of 2
	static final int THRESHOLD_ARRAY_SIZE;
	// threshold to grow arrays only by (5/4) instead of (3/2)
	static final long THRESHOLD_HUGE_ARRAY_SIZE;
	static final int[] ARRAY_SIZES = new int[BUCKETS];

	static {
		// initialize buckets for int/float arrays
		int arraySize = MIN_ARRAY_SIZE;

		int inc_lg = 2; // x4

		for (int i = 0; i < BUCKETS; i++, arraySize <<= inc_lg) {
			ARRAY_SIZES[i] = arraySize;

			if (DO_TRACE) {
				logInfo("arraySize[" + i + "]: " + arraySize);
			}

			if (arraySize >= THRESHOLD_SMALL_ARRAY_SIZE) {
				inc_lg = 1; // x2
			}
		}
		MAX_ARRAY_SIZE = arraySize >> inc_lg;

		if (MAX_ARRAY_SIZE <= 0) {
			throw new IllegalStateException("Invalid max array size !");
		}

		THRESHOLD_ARRAY_SIZE = 16 * 1024 * 1024; // >16M
		THRESHOLD_HUGE_ARRAY_SIZE = 48L * 1024 * 1024; // >48M

		if (DO_STATS || DO_MONITORS) {
			logInfo("ArrayCache.BUCKETS        = " + BUCKETS);
			logInfo("ArrayCache.MIN_ARRAY_SIZE = " + MIN_ARRAY_SIZE);
			logInfo("ArrayCache.MAX_ARRAY_SIZE = " + MAX_ARRAY_SIZE);
			logInfo("ArrayCache.ARRAY_SIZES = " + Arrays.toString(ARRAY_SIZES));
			logInfo("ArrayCache.THRESHOLD_ARRAY_SIZE = " + THRESHOLD_ARRAY_SIZE);
			logInfo("ArrayCache.THRESHOLD_HUGE_ARRAY_SIZE = " + THRESHOLD_HUGE_ARRAY_SIZE);
		}
	}

	private ArrayCacheConst() {
		// Utility class
	}

	// small methods used a lot (to be inlined / optimized by hotspot)

	static int getBucket(final int length) {
		for (int i = 0; i < ARRAY_SIZES.length; i++) {
			if (length <= ARRAY_SIZES[i]) {
				return i;
			}
		}
		return -1;
	}

	/**
	 * Return the new array size (~ x2)
	 * 
	 * @param curSize  current used size
	 * @param needSize needed size
	 * @return new array size
	 */
	public static int getNewSize(final int curSize, final int needSize) {
		// check if needSize is negative or integer overflow:
		if (needSize < 0) {
			// hard overflow failure - we can't even accommodate
			// new items without overflowing
			throw new ArrayIndexOutOfBoundsException("array exceeds maximum capacity !");
		}
		assert curSize >= 0;
		final int initial = curSize;
		int size;
		if (initial > THRESHOLD_ARRAY_SIZE) {
			size = initial + (initial >> 1); // x(3/2)
		} else {
			size = (initial << 1); // x2
		}
		// ensure the new size is >= needed size:
		if (size < needSize) {
			// align to 4096 (may overflow):
			size = ((needSize >> 12) + 1) << 12;
		}
		// check integer overflow:
		if (size < 0) {
			// resize to maximum capacity:
			size = Integer.MAX_VALUE;
		}
		return size;
	}

	/**
	 * Return the new array size (~ x2)
	 * 
	 * @param curSize  current used size
	 * @param needSize needed size
	 * @return new array size
	 */
	public static long getNewLargeSize(final long curSize, final long needSize) {
		// check if needSize is negative or integer overflow:
		if ((needSize >> 31L) != 0L) {
			// hard overflow failure - we can't even accommodate
			// new items without overflowing
			throw new ArrayIndexOutOfBoundsException("array exceeds maximum capacity !");
		}
		assert curSize >= 0L;
		long size;
		if (curSize > THRESHOLD_HUGE_ARRAY_SIZE) {
			size = curSize + (curSize >> 2L); // x(5/4)
		} else if (curSize > THRESHOLD_ARRAY_SIZE) {
			size = curSize + (curSize >> 1L); // x(3/2)
		} else if (curSize > THRESHOLD_SMALL_ARRAY_SIZE) {
			size = (curSize << 1L); // x2
		} else {
			size = (curSize << 2L); // x4
		}
		// ensure the new size is >= needed size:
		if (size < needSize) {
			// align to 4096:
			size = ((needSize >> 12L) + 1L) << 12L;
		}
		// check integer overflow:
		if (size > Integer.MAX_VALUE) {
			// resize to maximum capacity:
			size = Integer.MAX_VALUE;
		}
		return size;
	}

	static final class CacheStats {
		final String name;
		final BucketStats[] bucketStats;
		int resize = 0;
		int oversize = 0;
		long totalInitial = 0L;

		CacheStats(final String name) {
			this.name = name;

			bucketStats = new BucketStats[BUCKETS];
			for (int i = 0; i < BUCKETS; i++) {
				bucketStats[i] = new BucketStats();
			}
		}

		void reset() {
			resize = 0;
			oversize = 0;

			for (int i = 0; i < BUCKETS; i++) {
				bucketStats[i].reset();
			}
		}

		long dumpStats() {
			long totalCacheBytes = 0L;

			if (DO_STATS) {
				for (int i = 0; i < BUCKETS; i++) {
					final BucketStats s = bucketStats[i];

					if (s.maxSize != 0) {
						totalCacheBytes += getByteFactor() * (s.maxSize * ARRAY_SIZES[i]);
					}
				}

				if (totalInitial != 0L || totalCacheBytes != 0L || resize != 0 || oversize != 0) {
					logInfo(name + ": resize: " + resize + " - oversize: " + oversize + " - initial: " + getTotalInitialBytes() + " bytes (" + totalInitial
							+ " elements)" + " - cache: " + totalCacheBytes + " bytes");
				}

				if (totalCacheBytes != 0L) {
					logInfo(name + ": usage stats:");

					for (int i = 0; i < BUCKETS; i++) {
						final BucketStats s = bucketStats[i];

						if (s.getOp != 0) {
							logInfo("  Bucket[" + ARRAY_SIZES[i] + "]: " + "get: " + s.getOp + " - put: " + s.returnOp + " - create: " + s.createOp
									+ " :: max size: " + s.maxSize);
						}
					}
				}
			}
			return totalCacheBytes;
		}

		private int getByteFactor() {
			int factor = 1;
			if (name.contains("Int") || name.contains("Float")) {
				factor = 4;
			} else if (name.contains("Double")) {
				factor = 8;
			}
			return factor;
		}

		long getTotalInitialBytes() {
			return getByteFactor() * totalInitial;
		}
	}

	static final class BucketStats {
		int getOp = 0;
		int createOp = 0;
		int returnOp = 0;
		int maxSize = 0;

		void reset() {
			getOp = 0;
			createOp = 0;
			returnOp = 0;
			maxSize = 0;
		}

		void updateMaxSize(final int size) {
			if (size > maxSize) {
				maxSize = size;
			}
		}
	}
}
